# !/usr/bin/env python
# -*- coding:utf-8 -*-
# @Time      :2022/7/30 0030 13:33
# @Author    :jiaxuesong


"""
定义一个类
    定义初始化方法
        获取所有测试数据绑定为实力属性

    定义一个方法：根据当前用例的id，执行依赖的前置用例
        获取用于判断是否有前置用例的关键字段：rely、caseid、header、value
        判断是否有前置用例，判断是否是第一条测试用例，判断caseid不能为空
            是：根据正则找到请求头、请求体里面依赖的Set-Cookie，（可以封装一个函数）
                执行前置用例，获取依赖字段的数据：（可以封装 一个执行前置用例的方法）
                将取到的以来字段进行替换，替换原来的数据
                返回替换好的数据
            否：返回当前的header和body

    定义一个方法：提取需要依赖的请求头、体的字段
        根据正则提取依赖的字段，得到一个列表
        判断得到的列表是否有数据
            是：返回依赖字段
            否：返回NULL

    定义一个方法：执行前置用例，根据准备好的目标字段，提取数据
        准备前置用例，需要的数据
        调用configHttp进行请求得到结果
        判断请求头里面是否有依赖字数据，有则根据依赖进行替换
        判断请求体是否有以来数据，有则根据依赖进行替换
        返回依赖字段
"""
from hight_interface_test.common.log import *
from hight_interface_test.common.readExcle import ReadExcle
import re
from hight_interface_test.common.configHttp import *
from jsonpath import jsonpath
# 定义一个类
class Presovlve(object):
#     定义初始化方法
    def __init__(self, testdata):
#         获取所有测试数据绑定为实力属性
        self.testdata = testdata
#     定义一个方法：根据当前用例的id，执行依赖的前置用例
    def presolve(self, id):
        logger.debug(f'id:{id}, testdata:{self.testdata}')
#         获取用于判断是否有前置用例的关键字段：rely、caseid、header、value
        rely = self.testdata[int(id) - 1]['rely']
        caseid = self.testdata[int(id) - 1]['caseid']
        header = self.testdata[int(id) - 1]['header']
        value = self.testdata[int(id) - 1]['value']
        print(rely, caseid, header, value)
#         判断是否有前置用例，判断是否是第一条测试用例，判断caseid不能为空
        if rely.lower() == 'y' and id != '1' and caseid != '':
#             是：根据正则找到请求头、请求体里面依赖的Set-Cookie，（可以封装一个函数）
            goal_h = self.get_predata(header)
            goal_b = self.get_predata(value)
#                 执行前置用例，获取依赖字段的数据：（可以封装 一个执行前置用例的方法）
            h, b = self.run_pre(caseid, goal_h, goal_b)
#                 将取到的以来字段进行替换，替换原来的数据
            if h != None:
                header = header.replace('${' + goal_h + '}', h)
#                 返回替换好的数据
            if b != None:
                value = value.replace('${' + goal_b + '}', b)
            # 返回替换好的数据
            return header, value
#             否：返回当前的header和body
        else:
            return header, value


# 定义一个方法：提取需要依赖的请求头、体的字段
    def get_predata(self, data):
# 根据正则提取依赖的字段，得到一个列表
        res = re.findall( r"\$\{(.*?)\}", data)
# 判断得到的列表是否有数据
        if len(res) != 0:
# 是：返回依赖字段
            res_data = res[0]
# 否：返回NULL
        else:
            res_data = None
        return res_data


    # 定义一个方法：执行前置用例，根据准备好的目标字段，提取数据
    def run_pre(self, caseid, goal_h = None, goal_b = None):
    # 准备前置用例，需要的数据
        preUrl = self.testdata[int(caseid) - 1]['interfaceUrl']
        premethod = self.testdata[int(caseid) - 1]['method']
        prevalue = self.testdata[int(caseid) - 1]['value']
        preheader = self.testdata[int(caseid) - 1]['header']
    # 调用configHttp进行请求得到结果
        ch = ConfigHttp(premethod, preUrl, eval(prevalue), eval(preheader))
        res = ch.run()
        print(res.text)
    # 判断请求头里面是否有依赖字数据，有则根据依赖进行替换
        if goal_h != None:
    # 判断请求体是否有以来数据，有则根据依赖进行替换
            goal_h = res.headers[goal_h]
        if goal_b != None:
            goal_b = jsonpath(res.json(), '$..' + goal_b)[0]
    # 返回依赖字段
        return goal_h, goal_b


if __name__ == '__main__':
    testdata = ReadExcle().read()
    pv = Presovlve(testdata)
    # res.presolve(3)
    # print(pv.get_predata('{"cookie":"${Set-Cookie}"}'))
    #
    # print(pv.run_pre('1', 'Set-Cookie', 'username'))
    print(pv.run_pre(2))